home *** CD-ROM | disk | FTP | other *** search
/ Sprite 1984 - 1993 / Sprite 1984 - 1993.iso / src / lib / c / unixSyscall / RCS / flock.c,v < prev    next >
Encoding:
Text File  |  1991-12-10  |  5.8 KB  |  289 lines
  1. head     1.2;
  2. branch   ;
  3. access   ;
  4. symbols  sprited:1.2.1;
  5. locks    ; strict;
  6. comment  @ * @;
  7.  
  8.  
  9. 1.2
  10. date     89.01.06.08.03.34;  author brent;  state Exp;
  11. branches 1.2.1.1;
  12. next     1.1;
  13.  
  14. 1.1
  15. date     88.06.19.14.31.17;  author ouster;  state Exp;
  16. branches ;
  17. next     ;
  18.  
  19. 1.2.1.1
  20. date     91.12.10.15.46.34;  author kupfer;  state Exp;
  21. branches ;
  22. next     ;
  23.  
  24.  
  25. desc
  26. @@
  27.  
  28.  
  29. 1.2
  30. log
  31. @Nuked user-level lock clean up.  It isn't correct and is
  32. correctly superceeded by kernel-level cleanup.
  33. @
  34. text
  35. @/* 
  36.  * flock.c --
  37.  *
  38.  *    Procedure to map from Unix flock system call to Sprite.
  39.  *
  40.  * Copyright 1987 Regents of the University of California
  41.  * All rights reserved.
  42.  */
  43.  
  44. #ifndef lint
  45. static char rcsid[] = "$Header: /sprite/src/lib/c/unixSyscall/RCS/flock.c,v 1.1 88/06/19 14:31:17 ouster Exp Locker: brent $ SPRITE (Berkeley)";
  46. #endif not lint
  47.  
  48. #include "sprite.h"
  49. #include "fs.h"
  50. #include <bit.h>
  51.  
  52. #include "compatInt.h"
  53. #include <sys/file.h>
  54. #include <errno.h>
  55. #include <stdlib.h>
  56.  
  57.  
  58. /*
  59.  *----------------------------------------------------------------------
  60.  *
  61.  * flock --
  62.  *
  63.  *    Procedure to map from Unix flock system call to Sprite Ioc_Lock/Unlock.
  64.  *
  65.  * Results:
  66.  *      UNIX_SUCCESS    - the call was successful.
  67.  *      UNIX_ERROR      - the call was not successful.
  68.  *                        The actual error code stored in errno.
  69.  *
  70.  * Side effects:
  71.  *    None.
  72.  *
  73.  *----------------------------------------------------------------------
  74.  */
  75.  
  76. int
  77. flock(descriptor, operation)
  78.     int descriptor;        /* descriptor for stream to lock */
  79.     int operation;        /* flags for locking descriptor */
  80. {
  81.     ReturnStatus status;
  82.     int spriteLockOp = 0;
  83.  
  84.     if (operation & LOCK_EX) {
  85.     spriteLockOp |= IOC_LOCK_EXCLUSIVE;
  86.     } else if (operation & LOCK_SH) {
  87.     spriteLockOp |= IOC_LOCK_SHARED;
  88.     }
  89.     if (operation & LOCK_NB) {
  90.     spriteLockOp |= IOC_LOCK_NO_BLOCK;
  91.     }
  92.     if (operation & LOCK_UN) {
  93.     status = Ioc_Unlock(descriptor, spriteLockOp);
  94.     } else {
  95.     status = Ioc_Lock(descriptor, spriteLockOp);
  96.     }
  97.     if (status != SUCCESS) {
  98.     errno = Compat_MapCode(status);
  99.     return(UNIX_ERROR);
  100.     } else {
  101.     return(UNIX_SUCCESS);
  102.     }
  103. }
  104.  
  105. /*
  106.  *----------------------------------------------------------------------
  107.  *
  108.  * Unix_CloseLock --
  109.  *
  110.  *    Release any locks held by this process on the given descriptor
  111.  *    before it is closed. Called by close().
  112.  *
  113.  *    This is superceeded by the cleanup done in the Sprite kernel.
  114.  *
  115.  * Results:
  116.  *    None.
  117.  *
  118.  * Side Effects:
  119.  *    None.
  120.  *
  121.  *----------------------------------------------------------------------
  122.  */
  123. /*ARGSUSED*/
  124. void
  125. Unix_CloseLock (fd)
  126.     int fd;
  127. {
  128.     return;
  129. }
  130.  
  131. @
  132.  
  133.  
  134. 1.2.1.1
  135. log
  136. @Initial branch for Sprite server.
  137. @
  138. text
  139. @d11 1
  140. a11 1
  141. static char rcsid[] = "$Header: /sprite/src/lib/c/unixSyscall/RCS/flock.c,v 1.2 89/01/06 08:03:34 brent Exp $ SPRITE (Berkeley)";
  142. @
  143.  
  144.  
  145. 1.1
  146. log
  147. @Initial revision
  148. @
  149. text
  150. @d11 1
  151. a11 1
  152. static char rcsid[] = "$Header: flock.c,v 1.4 88/01/07 11:57:06 deboor Exp $ SPRITE (Berkeley)";
  153. a22 4
  154. static int *exLocks = (int *)0;
  155. static int *shLocks = (int *)0;
  156. static int maskWidth = 0;
  157.  
  158. d27 1
  159. a27 1
  160.  * UnlockAll --
  161. d29 1
  162. a29 2
  163.  *    An exit handler to make sure all our locks are released before
  164.  *    we exit...
  165. d32 3
  166. a34 1
  167.  *    None
  168. d36 2
  169. a37 2
  170.  * Side Effects:
  171.  *    Any locks we held are released
  172. d41 5
  173. a45 2
  174. static void
  175. UnlockAll()
  176. d47 2
  177. a48 1
  178.     int        fd;
  179. d50 4
  180. a53 3
  181.     while ((fd = Bit_FindFirstSet(maskWidth, exLocks)) >= 0) {
  182.     (void) Ioc_Unlock (fd, IOC_LOCK_EXCLUSIVE);
  183.     Bit_Clear (fd, exLocks);
  184. d55 2
  185. a56 3
  186.     while ((fd = Bit_FindFirstSet(maskWidth, shLocks)) >= 0) {
  187.     (void) Ioc_Unlock (fd, IOC_LOCK_SHARED);
  188.     Bit_Clear (fd, shLocks);
  189. d58 11
  190. a69 1
  191.  
  192. d79 2
  193. d85 1
  194. a85 2
  195.  *    Any locks will be released and the bit for the fd cleared in the
  196.  *    corresponding mask.
  197. d89 1
  198. d94 1
  199. a94 10
  200.     if (fd >= maskWidth || fd < 0) {
  201.     return;
  202.     }
  203.     if (Bit_IsSet (fd, exLocks)) {
  204.     Ioc_Unlock (fd, IOC_LOCK_EXCLUSIVE);
  205.     Bit_Clear (fd, exLocks);
  206.     } else if (Bit_IsSet (fd, shLocks)) {
  207.     Ioc_Unlock (fd, IOC_LOCK_SHARED);
  208.     Bit_Clear (fd, shLocks);
  209.     }
  210. a95 18
  211.  
  212. /*
  213.  *----------------------------------------------------------------------
  214.  *
  215.  * flock --
  216.  *
  217.  *    Procedure to map from Unix flock system call to Sprite IOControls.
  218.  *
  219.  * Results:
  220.  *      UNIX_SUCCESS    - the call was successful.
  221.  *      UNIX_ERROR      - the call was not successful.
  222.  *                        The actual error code stored in errno.
  223.  *
  224.  * Side effects:
  225.  *    None.
  226.  *
  227.  *----------------------------------------------------------------------
  228.  */
  229. a96 58
  230. int
  231. flock(descriptor, operation)
  232.     int descriptor;        /* descriptor for stream to lock */
  233.     int operation;        /* flags for locking descriptor */
  234. {
  235.     ReturnStatus status;    /* result returned by Fs_Lock */
  236.     static Boolean initialized = FALSE;
  237.  
  238.     if (!initialized) {
  239.     atexit (UnlockAll);
  240.     initialized = TRUE;
  241.     }
  242.  
  243.     if (operation & LOCK_UN) {
  244.     int    lockType;
  245.  
  246.     if (descriptor >= maskWidth) {
  247.         return (UNIX_SUCCESS);
  248.     }
  249.     if (descriptor < 0) {
  250.         errno = EBADF;
  251.         return (UNIX_ERROR);
  252.     }
  253.     if (Bit_IsSet (descriptor, shLocks)) {
  254.         lockType = IOC_LOCK_SHARED;
  255.         Bit_Clear (descriptor, shLocks);
  256.     } else if (Bit_IsSet (descriptor, exLocks)) {
  257.         lockType = IOC_LOCK_EXCLUSIVE;
  258.         Bit_Clear (descriptor, exLocks);
  259.     } else {
  260.         return (UNIX_SUCCESS);
  261.     }
  262.     status = Ioc_Unlock (descriptor, lockType);
  263.     } else {
  264.     if (operation & LOCK_NB) {
  265.         operation = (operation & 3) | IOC_LOCK_NO_BLOCK;
  266.     }
  267.     status = Ioc_Lock (descriptor, operation);
  268.     if (status == SUCCESS) {
  269.         if (descriptor >= maskWidth) {
  270.         exLocks = Bit_Expand (descriptor+1, maskWidth, exLocks);
  271.         shLocks = Bit_Expand (descriptor+1, maskWidth, shLocks);
  272.         maskWidth = descriptor+1;
  273.         }
  274.         if (operation & LOCK_EX) {
  275.         Bit_Set (descriptor, exLocks);
  276.         } else {
  277.         Bit_Set (descriptor, shLocks);
  278.         }
  279.     }
  280.     }
  281.     if (status != SUCCESS) {
  282.     errno = Compat_MapCode(status);
  283.     return(UNIX_ERROR);
  284.     } else {
  285.     return(UNIX_SUCCESS);
  286.     }
  287. }
  288. @
  289.